home *** CD-ROM | disk | FTP | other *** search
/ SGI Freeware 1999 August / SGI Freeware 1999 August.iso / dist / fw_kdelibs.idb / usr / freeware / kde / include / ktablistbox.h.z / ktablistbox.h
Encoding:
C/C++ Source or Header  |  1999-01-26  |  18.0 KB  |  524 lines
  1. /* This file is part of the KDE libraries
  2.     Copyright (C) 1997 The KDE Team
  3.  
  4.     This library is free software; you can redistribute it and/or
  5.     modify it under the terms of the GNU Library General Public
  6.     License as published by the Free Software Foundation; either
  7.     version 2 of the License, or (at your option) any later version.
  8.  
  9.     This library is distributed in the hope that it will be useful,
  10.     but WITHOUT ANY WARRANTY; without even the implied warranty of
  11.     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12.     Library General Public License for more details.
  13.  
  14.     You should have received a copy of the GNU Library General Public License
  15.     along with this library; see the file COPYING.LIB.  If not, write to
  16.     the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  17.     Boston, MA 02111-1307, USA.
  18. */
  19. /* Written by Stefan Taferner <taferner@kde.org>
  20.  *            Alessandro Russo <axela@bigfoot.com>
  21.  * A multi column listbox. Requires the Qt widget set.
  22.  */
  23. #ifndef KTabListBox_h
  24. #define KTabListBox_h
  25.  
  26. #undef del_item
  27. #include <qdict.h>
  28. #include <qtablevw.h>
  29. #include <qcolor.h>
  30. #include <qpixmap.h>
  31. #include <drag.h>
  32. #include <stdlib.h>
  33.  
  34. #define MAX_SEP_CHARS 16
  35.  
  36. class KTabListBoxColumn;
  37. class KTabListBoxTable;
  38. class KTabListBoxItem;
  39. class KTabListBox;
  40. class KNumCheckButton;
  41.  
  42. typedef QDict<QPixmap> KTabListBoxDict;
  43.  
  44. //-----------------------------------------------------
  45. /**
  46. * Provides a different type of Check button.
  47. * 
  48. */
  49. class KNumCheckButton : public QWidget
  50. {
  51.     Q_OBJECT
  52. public:
  53.     KNumCheckButton( QWidget *_parent = 0L, const char *name = 0L );
  54.     ~KNumCheckButton() {};
  55.     void setText( const char * );
  56.      
  57. signals:
  58.     void        selected();
  59.     void        deselected();    
  60.     /** leftbutton=true if is a leftbutton, =false if is a rightbutton
  61.     *   centerbutton doubleclick events aren't emitted.
  62.     */
  63.     void    doubleclick(bool leftbutton);
  64.  
  65. protected:
  66.     virtual void leaveEvent( QEvent *_ev );
  67.     virtual void enterEvent( QEvent *_ev );
  68.     virtual void mousePressEvent( QMouseEvent * );
  69.     virtual void mouseDoubleClickEvent( QMouseEvent * );
  70.     virtual void paintEvent( QPaintEvent *event);    
  71.     
  72.  private:    
  73.     bool raised;
  74.     QString     btext;
  75. };
  76.  
  77.  
  78. //--------------------------------------------------
  79. #define KTabListBoxTableInherited QTableView
  80. class KTabListBoxTable: public QTableView
  81. {
  82.   Q_OBJECT
  83.   friend KTabListBox;
  84. public:
  85.   KTabListBoxTable(KTabListBox *owner=0);
  86.   virtual ~KTabListBoxTable();
  87.   void enableKey();
  88.   int findRealCol(int x);
  89.  
  90. protected:
  91.   virtual void focusInEvent(QFocusEvent*);
  92.   virtual void focusOutEvent(QFocusEvent*);
  93.   virtual void mouseDoubleClickEvent (QMouseEvent*);
  94.   virtual void mousePressEvent (QMouseEvent*);
  95.   virtual void mouseReleaseEvent (QMouseEvent*);
  96.   virtual void mouseMoveEvent (QMouseEvent*);
  97.   virtual void doItemSelection (QMouseEvent*, int idx);
  98.  
  99.   virtual void paintCell (QPainter*, int row, int col);
  100.   virtual int cellWidth (int col);
  101.  
  102.   void reconnectSBSignals (void);
  103.  
  104.   QPoint dragStartPos;
  105.   int dragCol, dragRow;
  106.   int selIdx;
  107.   bool dragging;
  108. };
  109.  
  110.  
  111. //--------------------------------------------------
  112. #define KTabListBoxInherited KDNDWidget
  113.  
  114. /** A multi column listbox
  115.  * Features:
  116.  *  - User resizeable columns.
  117.  *  - The order of columns can be changed with drag&drop. (Alex)
  118.  *  - 3 modes: Standard, SimpleOrder, ComplexOrder. (Alex)
  119.  * ToDo: 
  120.  *  - Configurable vertical column divisor lines. 
  121.  *  - Save all setting to config file.
  122.  *  - fix flickering into column headers.
  123.  */
  124. class KTabListBox : public KDNDWidget
  125. {
  126.   Q_OBJECT
  127.   friend KTabListBoxTable;
  128.   friend KTabListBoxColumn;
  129.  
  130. public:
  131.   enum ColumnType { TextColumn, PixmapColumn, MixedColumn };
  132.   enum OrderMode { Ascending, Descending };
  133.   enum OrderType { NoOrder, SimpleOrder, ComplexOrder };
  134.  
  135.   KTabListBox (QWidget *parent=0, const char *name=0, 
  136.            int columns=1, WFlags f=0);
  137.   virtual ~KTabListBox();
  138.  
  139.   /** This enable the key-bindings (and set StrongFocus!)
  140.    * if you don't want StrongFocus you can implement your own keyPressEvent
  141.    * and send an event to KTabListBox from there... */
  142.   void enableKey(void) { lbox.enableKey(); }
  143.   
  144.   /** Returns the number of rows */
  145.   uint count (void) const { return numRows(); };
  146.   
  147.   /** Insert a line before given index, using the separator character to separate the fields. If no index is given the line is appended at the end. Returns index of inserted item. */
  148.   virtual void insertItem (const char* string, int itemIndex=-1);
  149.  
  150.   /** Append a QStrList */
  151.   void appendStrList( QStrList const *strLst );
  152.  
  153.   /** Same as insertItem, but always appends the new item. */
  154.   void appendItem (const char* string) { insertItem(string); }
  155.  
  156.   /** Change contents of a line using the separator character to separate the fields. */
  157.   virtual void changeItem (const char* string, int itemIndex);
  158.  
  159.   /** Change part of the contents of a line. */
  160.   virtual void changeItemPart (const char* string, int itemIndex, int column);
  161.  
  162.   /** Change color of line. Changes last inserted item when itemIndex==-1 */
  163.   virtual void changeItemColor (const QColor& color, int itemIndex=-1);
  164.  
  165.   /** Get number of pixels one tab character stands for. Default: 10 */
  166.   int tabWidth(void) const { return tabPixels; }
  167.   /** Set number of pixels one tab character stands for. Default: 10 */
  168.   virtual void setTabWidth(int);
  169.  
  170.   /** Returns contents of given row/column. If col is not set the
  171.    contents of the whole row is returned, seperated with the current 
  172.    seperation character. In this case the string returned is a 
  173.    temporary string that will change on the next text() call on any
  174.    KTabListBox object. */
  175.   const QString& text(int idx, int col=-1) const;
  176.  
  177.   /** Remove one item from the list. */
  178.   virtual void removeItem (int itemIndex);
  179.  
  180.   /** Remove contents of listbox */
  181.   virtual void clear (void);
  182.  
  183.   /** Return index of current item */
  184.   int currentItem (void) const { return current; }
  185.  
  186.   /** Set the current (selected) column. colId is the value that
  187.     is transfered with the selected() signal that is emited. */
  188.   virtual void setCurrentItem (int idx, int colId=-1);
  189.  
  190.   /** Unmark all items */
  191.   virtual void unmarkAll (void);
  192.  
  193.   /** Mark/unmark item with index idx. */
  194.   virtual void markItem (int idx, int colId=-1);
  195.   virtual void unmarkItem (int idx);
  196.  
  197.   /** Returns TRUE if item with given index is marked. */
  198.   virtual bool isMarked (int idx) const;
  199.  
  200.   /** Find item at given screen y position. */
  201.   int findItem (int yPos) const { return (itemShowList[lbox.findRow(yPos)]); }
  202.  
  203.   /** Returns first item that is currently displayed in the widget. */
  204.   int topItem (void) const { return (itemShowList[lbox.topCell()]); }
  205.  
  206.   /** Change first displayed item by repositioning the visible part
  207.     of the list. */
  208.   void setTopItem (int idx) { lbox.setTopCell(itemPosList(idx)); }
  209.  
  210.   /** Set number of columns. Warning: this *deletes* the contents
  211.     of the listbox. */
  212.   virtual void setNumCols (int);
  213.  
  214.   /** Set number of rows in the listbox. The contents stays as it is. */
  215.   virtual void setNumRows (int);
  216.  
  217.   /** See the docs for the QTableView class. */
  218.   int numRows (void) const { return lbox.numRows(); }
  219.   /** See the docs for the QTableView class. */
  220.   int numCols (void) const { return lbox.numCols(); }
  221.   /** See the docs for the QTableView class. */
  222.   int cellWidth (int col) { return lbox.cellWidth(col); }
  223.   /** See the docs for the QTableView class. */
  224.   int totalWidth (void) { return lbox.totalWidth(); }
  225.   /** See the docs for the QTableView class. */
  226.   int cellHeight (int row) { return lbox.cellHeight(row); }
  227.   /** See the docs for the QTableView class. */
  228.   int totalHeight (void) { return lbox.totalHeight(); }
  229.   /** See the docs for the QTableView class. */
  230.   int topCell (void) const { return itemShowList[lbox.topCell()]; }
  231.   /** See the docs for the QTableView class. */
  232.   int leftCell (void) const { return colShowList[lbox.leftCell()]; }
  233.   /** See the docs for the QTableView class. */
  234.   int lastColVisible (void) const { return colShowList[lbox.lastColVisible()]; }
  235.   /** See the docs for the QTableView class. */
  236.   int lastRowVisible (void) const { return itemShowList[lbox.lastRowVisible()]; }
  237.   /** See the docs for the QTableView class. */
  238.   bool autoUpdate (void) const { return lbox.autoUpdate(); }
  239.   /** See the docs for the QTableView class. */
  240.   void setAutoUpdate (bool upd) { lbox.setAutoUpdate(upd); }
  241.   /** See the docs for the QTableView class. */
  242.   void clearTableFlags(uint f=~0) { lbox.clearTableFlags(f); }
  243.   /** See the docs for the QTableView class. */
  244.   uint tableFlags(void) { return lbox.tableFlags(); }
  245.   /** See the docs for the QTableView class. */
  246.   bool testTableFlags(uint f) { return lbox.testTableFlags(f); }
  247.   /** See the docs for the QTableView class. */
  248.   void setTableFlags(uint f) { lbox.setTableFlags(f); }
  249.   /** See the docs for the QTableView class. */
  250.   int findCol(int x) { return lbox.findRealCol(x); }
  251.   /** See the docs for the QTableView class. */
  252.   int findRow(int y) { return itemShowList[lbox.findRow(y)]; }
  253.   /** See the docs for the QTableView class. */
  254.   bool colXPos(int col, int* x) { return lbox.colXPos(colPosList(col),x); }
  255.   /** See the docs for the QTableView class. */
  256.   bool rowYPos(int row, int* y) { return lbox.rowYPos(itemPosList(row),y); }
  257.  
  258.   /** This call the 'compar' functions if they were been defined in 
  259.   * setColumn or else use strcmp. (i.e. if you want a case-insensitive sort
  260.   * put strcasecmp in setColumn call).
  261.   * That compar function must take as arguments two char *, and must return
  262.   * an integer less  than, equal  to,  or  greater than zero if the first
  263.   * argument is considered to be respectively  less  than,  equal  to, 
  264.   * or greater than the second. */
  265.   virtual void reorderRows();
  266.   
  267.   /** Set column caption, width, type,order-type and order-mode */
  268.   virtual void setColumn (int col, const char* caption, 
  269.               int width=0, ColumnType type=TextColumn,
  270.               OrderType ordt=NoOrder,
  271.               OrderMode omode=Descending,
  272.               bool verticalLine=false,
  273.               int (*compar)(const char *, const char *)=0L);
  274.  
  275.   /** Set column width. */
  276.   virtual void setColumnWidth (int col, int width=0);
  277.   /** Get column width. */
  278.   int columnWidth (int col) { return lbox.cellWidth(col); }
  279.  
  280.   /** Set default width of all columns. */
  281.   virtual void setDefaultColumnWidth(int width0, ...);
  282.  
  283.   /** change the Ascending/Descending mode of column col.*/
  284.   void changeMode(int col);
  285.   /** Clear all number-check-buttons (ComplexOrder only) */
  286.   void clearAllNum();
  287.   
  288.   /** Set separator character, e.g. '\t'. */
  289.   virtual void setSeparator (char sep) { sepChar = sep; } 
  290.  
  291.   /** Return separator character. */
  292.   virtual char separator (void) const { return sepChar; }
  293.  
  294.   /** For convenient access to the dictionary of pictures that this listbox understands. */
  295.   KTabListBoxDict& dict (void) { return pixDict; }
  296.  
  297.   void repaint (void);
  298.  
  299.   /** Indicates that a drag has started with given item. Returns TRUE if we are dragging, FALSE if drag-start failed. */
  300.   bool startDrag(int col, int row, const QPoint& mousePos);
  301.  
  302.   QPixmap& dndPixmap(void) { return dndDefaultPixmap; }
  303.  
  304.   /** Read the config file entries in the group with the name of the listbox and set the default column widths and those. */
  305.   virtual void readConfig(void);
  306.  
  307.   /** Write the config file entries in the group with the name of the listbox*/
  308.   virtual void writeConfig(void);
  309.   
  310.   /** Return the actual position of the colum in the table.*/
  311.   int colPosList(int num);
  312.   
  313.   /** Return the actual positon of the row number num.*/
  314.   int itemPosList(int num);
  315.  
  316.   /** Get/set font of the table. font() and setFont() apply to the
  317.     caption only. */
  318.   const QFont& tableFont(void) const { return lbox.font(); }
  319.   void setTableFont(const QFont& fnt) { lbox.setFont(fnt); }
  320.   
  321. signals:
  322.   /** emited when the current item changes (either via setCurrentItem() or via mouse single-click). */
  323.   void highlighted (int Index, int column);
  324.  
  325.   /** emitted when the user double-clicks into a line. */
  326.   void selected (int Index, int column);
  327.  
  328.   /** emitted when the user presses the right mouse button over a line. */
  329.   void popupMenu (int Index, int column);
  330.  
  331.   /** emitted when the user presses the middle mouse button over a line. */
  332.   void midClick (int Index, int column);
  333.  
  334.   /** emitted when the user clicks on a column header. */
  335.   void headerClicked (int column);
  336.  
  337. protected slots:
  338.   void horSbValue(int val);
  339.   void horSbSlidingDone();
  340.  
  341. protected:
  342.   /** Used to create new column objects. Overwrite this method
  343.    * in a subclass to have your own column objects (e.g. with custom
  344.    * data in it). You will then also need customData()/setCustomData()
  345.    * methods in here that access the elememts in itemList[]. */
  346.   virtual KTabListBoxColumn* newKTabListBoxColumn(void);
  347.  
  348.   bool itemVisible (int idx) { return lbox.rowIsVisible(idx); }
  349.   void updateItem (int idx, bool clear = TRUE);
  350.   bool needsUpdate (int id);
  351.  
  352.   /// Internal method called by keyPressEvent.
  353.   void setCItem  (int idx);
  354.   /// Adjust the number in the number check boxes.
  355.   void adjustNumber(int num);
  356.   // This should really go into kdecore and should be used by all
  357.   // apps that have long scrollable widgets.
  358.   void flushKeys();
  359.   
  360.   /// For internal use.
  361.   bool recursiveSort(int level,int n,KTabListBoxColumn **c,int *iCol);
  362.   
  363.   KTabListBoxItem* getItem (int idx);
  364.   const KTabListBoxItem* getItem (int idx) const;
  365.  
  366.   virtual void keyPressEvent(QKeyEvent*);
  367.   virtual void resizeEvent (QResizeEvent*);
  368.   virtual void paintEvent (QPaintEvent*);
  369.   virtual void mouseMoveEvent(QMouseEvent*);
  370.   virtual void mousePressEvent(QMouseEvent*);
  371.   virtual void mouseReleaseEvent(QMouseEvent*);
  372.  
  373.   /** Resize item array. Per default enlarge it to double size. */
  374.   virtual void resizeList (int newNumItems=-1);
  375.  
  376.   /** Called to set drag data, size, and type. If this method returns FALSE then no drag occurs. */
  377.   virtual bool prepareForDrag (int col, int row, char** data, int* size, 
  378.                    int* type);
  379.  
  380.   /** Internal method that handles resizing of columns with the mouse. */
  381.   virtual void doMouseResizeCol(QMouseEvent*);
  382.  
  383.   /** Internal method that handles moving of columns with the mouse. */
  384.   virtual void doMouseMoveCol(QMouseEvent*);
  385.   
  386.   // This array contain the list of columns as they are inserted.
  387.   KTabListBoxColumn**    colList;
  388.   // This array contain the column numbers as they are shown.
  389.   int *colShowList;
  390.   // This array contain the row numbers as they are shown.
  391.   int *itemShowList;
  392.   KTabListBoxItem**    itemList;
  393.   int            maxItems, numColumns;
  394.   int            current;
  395.   char            sepChar;
  396.   KTabListBoxDict    pixDict;
  397.   KTabListBoxTable    lbox;
  398.   int            labelHeight;
  399.   
  400.   QPixmap        dndDefaultPixmap;
  401.   QPixmap        upPix,downPix;
  402.   QPixmap        disabledUpPix,disabledDownPix;
  403.   int            columnPadding;
  404.   QColor        highlightColor;
  405.   int            tabPixels;
  406.   bool            mResizeCol;
  407.   bool            stopOrdering;
  408.   bool            needsSort;
  409.   /// contain the number of the last column where the user clicked on checkbutton.
  410.   int                   lastSelectedColumn;
  411.   int            nMarked; //number of marked rows.
  412.   int            mSortCol;  // selected column for sorting order or -1
  413.  
  414.   int        mMouseCol; // column where the mouse action started
  415.                // (resize, click, reorder)
  416.   int        mMouseColLeft; // left offset of mouse column
  417.   int        mLastX; // Used for drawing the XORed rect in column-drag.
  418.   int        mMouseColWidth; // width of mouse column
  419.   QPoint        mMouseStart;
  420.   bool        mMouseAction;
  421.   bool        mMouseDragColumn; // true when dragging the header of a column.
  422.  
  423. private:
  424.   // Disabled copy constructor and operator=
  425.   KTabListBox (const KTabListBox &) {}
  426.   KTabListBox& operator= (const KTabListBox&) { return *this; }
  427. };
  428.  
  429.  
  430. //--------------------------------------------------
  431. class KTabListBoxItem
  432. {
  433. public:
  434.   KTabListBoxItem(int numColumns=1);
  435.   virtual ~KTabListBoxItem();
  436.  
  437.   virtual const QString& text(int column) const { return txt[column]; }
  438.   void setText (int column, const char *text) { txt[column] = text; }
  439.   virtual void setForeground (const QColor& fg ) { fgColor = fg; }
  440.   const QColor& foreground (void) { return fgColor; }
  441.  
  442.   KTabListBoxItem& operator= (const KTabListBoxItem&);
  443.  
  444.   int marked (void) const { return mark; }
  445.   bool isMarked (void) const { return (mark >= -1); }
  446.   virtual void setMarked (int m) { mark = m; }
  447.  
  448. private:
  449.   QString* txt;
  450.   int columns;
  451.   QColor fgColor;
  452.   int mark;
  453.  
  454.   friend class KTabListBox;
  455. };
  456.  
  457. typedef KTabListBoxItem* KTabListBoxItemPtr;
  458.  
  459.  
  460. //--------------------------------------------------
  461. class KTabListBoxColumn: public QObject
  462. {
  463.   Q_OBJECT
  464.  
  465. public:
  466.   KTabListBoxColumn (KTabListBox* parent, int w=0);
  467.   virtual ~KTabListBoxColumn();
  468.  
  469.   int width (void) const { return iwidth; }
  470.   virtual void setWidth (int w) { iwidth = w; }
  471.  
  472.   int defaultWidth (void) const { return idefwidth; }
  473.   virtual void setDefaultWidth (int w) { idefwidth = w; }
  474.  
  475.   virtual void setType (KTabListBox::ColumnType lbt) { colType = lbt; }
  476.   KTabListBox::ColumnType type (void) const { return colType; }
  477.  
  478.   /// @return true if need repaint.
  479.   virtual bool changeMode (void);
  480.   
  481.   virtual void setNumber(int num);
  482.   int number (void) const { return inumber;}
  483.   void hideCheckButton(void) { if(mbut) mbut->hide(); }
  484.   virtual void setOrder (KTabListBox::OrderType type,
  485.                              KTabListBox::OrderMode mode);
  486.   KTabListBox::OrderType orderType (void) const {return ordtype;}
  487.   KTabListBox::OrderMode orderMode (void) const {return ordmode;}
  488.   
  489.   virtual void paintCell (QPainter*, int row, const QString& string, 
  490.               bool marked);
  491.   virtual void paint (QPainter*);
  492.  
  493. protected slots:
  494.   virtual void setButton();
  495.   virtual void resetButton();
  496.   virtual void clearAll(bool leftbutton);
  497.   
  498. protected:
  499.   int iwidth, idefwidth, inumber;
  500.   KTabListBox::OrderMode ordmode;
  501.   KTabListBox::OrderType ordtype;
  502.   KTabListBox::ColumnType colType;
  503.   KTabListBox* parent;
  504.   KNumCheckButton *mbut;
  505. public:
  506.   int (*columnSort)(const char *, const char *);
  507.   bool vline; // if true print a vertical line to the end of column.
  508. };
  509.  
  510. typedef KTabListBoxColumn* KTabListBoxColumnPtr;
  511.  
  512.  
  513. inline KTabListBoxItem* KTabListBox :: getItem (int idx)
  514. {
  515.     return ((idx>=0 && idx<maxItems) ? itemList[idx] : (KTabListBoxItem*)0L);
  516. }
  517.  
  518. inline const KTabListBoxItem* KTabListBox :: getItem (int idx) const
  519. {
  520.   return ((idx>=0 && idx<maxItems) ? itemList[idx] : (KTabListBoxItem*)0L);
  521. }
  522.  
  523. #endif /*KTabListBox_h*/
  524.